// use regex::{Regex, escape};



use url::Url;
use linkify::{LinkFinder, LinkKind};
// use tokio::sync::OnceCell;
// use teloxide::types::{
// InlineKeyboardButtonKind, InlineKeyboardMarkup, MediaKind, Message, MessageEntity,
// MessageEntityKind, MessageKind,
// };
// macro_rules! regex {
//     ($re:literal $(,)?) => {{
//         static RE: OnceCell::sync::OnceCell<regex::Regex> = OnceCell::sync::OnceCell::new();
//         RE.get_or_init(|| regex::Regex::new($re).unwrap())
//     }};
// }
// use url::Url;
pub fn link_finder(text: String) -> Vec<String> {
    // let urls = Vec::new();
let urls = LinkFinder::new()
.kinds(&[LinkKind::Url])
// .url_must_have_scheme(false)
.links(&text)
.map(|link| link.as_str().to_owned())
// .map(|link| Url::parse(link.as_str()))
// .filter(|s| s.is_ok())
// .filter_map(|s|s.ok())
// .map(|s| s)
// .filter(|s| s.is_ok())
.collect::<Vec<String>>();

    // let pattern = ;
    //println!("{}", pattern);
    // let re = regex!(r"`(?P<origin>(?P<protocol>http[s]?:)?//(?P<host>[a-z0-9A-Z-_.]+))(?P<port>:\d+)?(?P<path>[/a-zA-Z0-9-\.]+)?(?P<search>\?[^#\n]+)?(?P<hash>#.*)?`gm");
    // let re = regex!(r"^(http|https)://[a-zA-Z0-9\-\.]+\.[a-z]{2,}(:[0-9]+)?(/.*)?$");

    // for mat in re.find_iter(text) {
    //     println!("{:#?}", mat);
    //     // if let Ok(url) = Url::parse(mat){
    //         // urls.push(url);
    //     }
    println!("Test2322");
    urls
    // let message_kind = &message.kind;
    // let mut urls: Vec<Url> = Vec::new();
    // parse_media_kind(message_kind, &mut urls);
    // if let Some(keyboard) = message.reply_markup() {
    //     parse_keyboard(keyboard, &mut urls);
    // }
    // urls
}
// fn entities_parse(entity: &MessageEntity, text: &String) -> Option<String> {
//     let mut res = None;
//     match &entity.kind {
//         MessageEntityKind::TextLink { url } => res = Some(url.to_string()),
//         MessageEntityKind::Url => {
//             let url: String = {
//                 let text = text;
//                 let start = entity.offset;
//                 let length = entity.length;
//                 text.chars().skip(start).take(length).collect()
//             };
//             info!("{:#?}", url);
//             res = Some(url);
//         }
//         _ => {}
//     };
//     res
// }
// fn parse_media_kind(message_kind: &MessageKind, urls: &mut Vec<Url>) {
//     match message_kind {
//         MessageKind::Common(message_common) => match &message_common.media_kind {
//             MediaKind::Text(text_data) => {
//                 //let mut urls: Vec<String> = Vec::new();
//                 for entity in &text_data.entities {
//                     let text = &text_data.text;
//                     if let Some(url) = entities_parse(entity, text) {
//                         if let Ok(url) = Url::parse(&url) {
//                             urls.push(url);
//                         }
//                     }
//                 }
//                 Some(urls);
//             }
//             MediaKind::Photo(data) => {
//                 for entity in &data.caption_entities {
//                     let caption = match &data.caption {
//                         Some(str) => str.to_string(),
//                         None => String::default(),
//                     };
//                     info!("{:#?}", caption);
//                     if let Some(url) = entities_parse(entity, &caption) {
//                         if let Ok(url) = Url::parse(&url) {
//                             urls.push(url);
//                         }
//                     }
//                 }
//             }
//             _ => {}
//         },
//         _ => {}
//     }
// }
// fn parse_keyboard(keyboard: &InlineKeyboardMarkup, urls: &mut Vec<Url>) {
//     for row in &keyboard.inline_keyboard {
//         for button in row {
//             match &button.kind {
//                 InlineKeyboardButtonKind::Url(url) => urls.push(url.to_owned()),
//                 _ => {}
//             }
//         }
//     }
// }
